#importing the library
import matplotlib as mpl
import matplotlib.pyplot as plt

plt.style.use('classic')

plt.style.available

#%matplotlib inline will lead to static images of your plot embedded in the notebook
%matplotlib inline

import numpy as np
x = np.linspace(0, 10, 100)

fig = plt.figure(figsize=(18,5))
plt.plot(x, np.sin(x), '-')
plt.plot(x, np.cos(x), '--');

fig.savefig('my_figure.png')

import os

os.getcwd()

from IPython.display import Image
Image('my_figure.png')

fig.canvas.get_supported_filetypes()

plt.figure(figsize=(18,6))  # create a plot figure

# create the first of two panels and set current axis
plt.subplot(2, 1, 1) # (rows, columns, panel number)
plt.plot(x, np.sin(x))

# create the second panel and set current axis
plt.subplot(2, 1, 2)
plt.plot(x, np.cos(x));

# First create a grid of plots
# ax will be an array of two Axes objects
fig, ax = plt.subplots(2)

# Call plot() method on the appropriate object
ax[0].plot(x, np.sin(x))
ax[1].plot(x, np.cos(x));

import pandas as pd
df = pd.read_table('https://archive.ics.uci.edu/ml/machine-learning-databases/yeast/yeast.data',sep='\s+',header=None)
df.columns = ['seq_name','mcg','gvh','alm','mit','erl','pox','vac','nuc','class']

df.head(3)

import matplotlib.pyplot as plt
plt.style.use('classic')
import numpy as np

%matplotlib inline

plt.hist(df.mcg) #histogram
plt.show()

# use a gray background
ax = plt.axes(axisbg='#E6E6E6')
ax.set_axisbelow(True)

# draw solid white grid lines
plt.grid(color='w', linestyle='solid')

# hide axis spines
for spine in ax.spines.values():
    spine.set_visible(False)

# hide top and right ticks
ax.xaxis.tick_bottom()
ax.yaxis.tick_left()

# lighten ticks and labels
ax.tick_params(colors='gray', direction='out')
for tick in ax.get_xticklabels():
    tick.set_color('gray')
for tick in ax.get_yticklabels():
    tick.set_color('gray')

# control face and edge color of histogram
ax.hist(df.mcg, edgecolor='#E6E6E6', color='#EE6666')

# use a gray background
plt.figure(figsize=(18,5))
ax = plt.axes(axisbg='#E6E6E6')
ax.set_axisbelow(True)

# draw solid white grid lines
plt.grid(color='w', linestyle='solid')

# hide axis spines
for spine in ax.spines.values():
    spine.set_visible(False)
    
# hide top and right ticks
ax.xaxis.tick_bottom()
ax.yaxis.tick_left()

# lighten ticks and labels
ax.tick_params(colors='gray', direction='out')
for tick in ax.get_xticklabels():
    tick.set_color('gray')
for tick in ax.get_yticklabels():
    tick.set_color('gray')
    
# control face and edge color of histogram
ax.hist(df.mcg, edgecolor='#E6E6E6', color='#EE6666');

# runtime configuration (rc)

IPython_default = plt.rcParams.copy()

IPython_default

#plt.rc function to change configuration

from matplotlib import cycler
colors = cycler('color',
                ['#EE6666', '#3388BB', '#9988DD',
                 '#EECC55', '#88BB44', '#FFBBBB'])
plt.rc('axes', facecolor='#E6E6E6', edgecolor='none',
       axisbelow=True, grid=True, prop_cycle=colors)
plt.rc('grid', color='w', linestyle='solid')
plt.rc('xtick', direction='out', color='gray')
plt.rc('ytick', direction='out', color='gray')
plt.rc('patch', edgecolor='#E6E6E6')
plt.rc('lines', linewidth=2)

plt.hist(df.mcg)
plt.show()

plt.figure(figsize=(18,5))
for i in range(1):
    plt.plot(df.mcg)

plt.figure(figsize=(18,5))
for i in range(2):
    plt.plot(df.mcg)

plt.figure(figsize=(18,5))
for i in range(3):
    plt.plot(df.mcg)

plt.figure(figsize=(18,5))
for i in range(4):
    plt.plot(df.mcg)

plt.figure(figsize=(18,5))
for i in range(5):
    plt.plot(df.mcg)

plt.figure(figsize=(18,5))
for i in range(6):
    plt.plot(df.mcg)

plt.style.available[:5]

#The basic way to switch to a stylesheet is to call
#plt.style.use('stylename')

#create a function that will make two basic types of plot
def hist_and_lines():
    np.random.seed(0)
    fig, ax = plt.subplots(1, 2, figsize=(18, 4))
    ax[0].hist(df.mcg)
    for i in range(3):
        ax[1].plot(df.mit)
    ax[1].legend(['mit'], loc='upper right')

hist_and_lines()

# reset rcParams
plt.rcParams.update(IPython_default);

with plt.style.context('fivethirtyeight'):
    hist_and_lines()

plt.style.available[:5]

with plt.style.context('bmh'):
    hist_and_lines()

with plt.style.context('dark_background'):
    hist_and_lines()

with plt.style.context('fast'):
    hist_and_lines()

with plt.style.context('ggplot'):
    hist_and_lines()

#seaborn style
import seaborn as sns
hist_and_lines()

%matplotlib inline
import matplotlib.pyplot as plt
plt.style.use('seaborn-whitegrid')
import numpy as np

fig = plt.figure(figsize=(18,5))
ax = plt.axes()

plt.figure(figsize=(18,5))
plt.plot(df.mcg, color='blue')        # specify color by name
plt.show()

plt.figure(figsize=(18,5))       # short color code (rgbcmyk)
plt.plot(df.mcg, color='g')    
plt.show()

plt.figure(figsize=(18,5))        # Grayscale between 0 and 1
plt.plot(df.mcg, color='0.75')    
plt.show()

plt.figure(figsize=(18,5))        # Hex code (RRGGBB from 00 to FF)
plt.plot(df.mcg, color='#FFDD44')    
plt.show()

plt.figure(figsize=(18,5))        # RGB tuple, values 0 to 1
plt.plot(df.mcg, color=(1.0,0.2,0.3))    
plt.show()

plt.figure(figsize=(18,5))        # all HTML color names supported
plt.plot(df.mcg, color='chartreuse')    
plt.show()

plt.figure(figsize=(18,5))        # RGB tuple, values 0 to 1
plt.plot(df.mcg, color=(1.0,0.2,0.3),linestyle='solid') 
plt.show()

plt.figure(figsize=(18,5))        # RGB tuple, values 0 to 1
plt.plot(df.mcg, color=(1.0,0.2,0.3),linestyle='dashed') 
plt.show()

plt.figure(figsize=(18,5))        # RGB tuple, values 0 to 1
plt.plot(df.mcg, color=(1.0,0.2,0.3),linestyle='dashdot') 
plt.show()

plt.figure(figsize=(18,5))        # RGB tuple, values 0 to 1
plt.plot(df.mcg, color=(1.0,0.2,0.3),linestyle='dotted') 
plt.show()

# you can use symbols
plt.figure(figsize=(18,5))        # RGB tuple, values 0 to 1
plt.plot(df.mcg, color=(1.0,0.2,0.3),linestyle='-') 
plt.show()

plt.figure(figsize=(18,5))        # RGB tuple, values 0 to 1
plt.plot(df.mcg, color=(1.0,0.2,0.3),linestyle='--') 
plt.show()

plt.figure(figsize=(18,5))        # RGB tuple, values 0 to 1
plt.plot(df.mcg, color=(1.0,0.2,0.3),linestyle='-.') 
plt.show()

plt.figure(figsize=(18,5))        # RGB tuple, values 0 to 1
plt.plot(df.mcg, color=(1.0,0.2,0.3),linestyle=':') 
plt.show()

#Adjusting the Plot: Axes Limits
plt.figure(figsize=(18,5)) 
plt.plot(df.mcg, np.square(df.mcg))
plt.xlim(0, 1)
plt.ylim(-0.5, 1.5);

#The plt.axis() method allows you to set the x and y limits with a single call, 
#by passing a list which specifies [xmin, xmax, ymin, ymax]
x = df.gvh
plt.plot(x, np.sin(x))
plt.axis([-1, 11, -1.5, 1.5]);

plt.plot(x, np.sin(x))
plt.axis('tight');

plt.plot(x, np.sin(x))
plt.axis('equal');

#labeling of plots: titles, axis labels, and simple legends
plt.plot(x, np.sin(x))
plt.title("A Sine Curve")
plt.xlabel("x")
plt.ylabel("sin(x)");

plt.plot(x, np.sin(x), '-g', label='sin(x)')
plt.plot(x, np.cos(x), ':b', label='cos(x)')
plt.axis('equal')

plt.legend();

#plt.xlabel() → ax.set_xlabel()
#plt.ylabel() → ax.set_ylabel()
#plt.xlim() → ax.set_xlim()
#plt.ylim() → ax.set_ylim()
#plt.title() → ax.set_title()

ax = plt.axes()
ax.plot(x, np.sin(x))
ax.set(xlim=(0, 1), ylim=(-2, 2),
       xlabel='x', ylabel='sin(x)',
       title='A Simple Plot');

df.info()

%matplotlib inline
import matplotlib.pyplot as plt
plt.style.use('seaborn-whitegrid')
import numpy as np

x = df.mcg
y = df.alm
plt.figure(figsize=(18,5))
plt.plot(x, y, 'o', color='black');

plt.figure(figsize=(18,5))
rng = np.random.RandomState(0)
for marker in ['o', '.', ',', 'x', '+', 'v', '^', '<', '>', 's', 'd']:
    plt.plot(rng.rand(5), rng.rand(5), marker,
             label="marker='{0}'".format(marker))
plt.legend(numpoints=1)
plt.xlim(0, 1.8);

plt.figure(figsize=(18,5))
plt.plot(x, y, '-ok');

plt.figure(figsize=(18,5))
plt.plot(x, y, '-p', color='gray',
         markersize=15, linewidth=4,
         markerfacecolor='white',
         markeredgecolor='gray',
         markeredgewidth=2)
plt.ylim(-1.2, 1.2);

df.info()
#plt.figure(figsize=(18,5))

plt.figure(figsize=(18,5))
plt.scatter(df.mcg, df.gvh, marker='o');

#use the alpha keyword to adjust the transparency level:
rng = np.random.RandomState(0)
x = rng.randn(100)
y = rng.randn(100)
colors = rng.rand(100)
sizes = 1000 * rng.rand(100)
plt.figure(figsize=(18,5))
plt.scatter(x, y, c=colors, s=sizes, alpha=0.3,
            cmap='viridis')
plt.colorbar();  # show color scale

from sklearn.datasets import load_iris
iris = load_iris()
features = iris.data.T
plt.figure(figsize=(18,5))
plt.scatter(features[0], features[1], alpha=0.2,
            s=100*features[3], c=iris.target, cmap='viridis')
plt.xlabel(iris.feature_names[0])
plt.ylabel(iris.feature_names[1]);
plt.colorbar()

#plt.plot should be preferred over plt.scatter for large datasets due to performance issues

#to display three-dimensional data in two dimensions use contours or color-coded regions

#There are three Matplotlib functions that can be helpful for this task: 
#1.plt.contour for contour plots
#2.plt.contourf for filled contour plots, and 
#3.plt.imshow for showing images

%matplotlib inline
import matplotlib.pyplot as plt
plt.style.use('seaborn-white')
import numpy as np

df.info()

X, Y = np.meshgrid(df.mcg, df.gvh)
Z = X + Y
plt.contour(X,Y,Z, colors='black')

plt.contour(X, Y, Z, 20, cmap='RdGy');

plt.contourf(X, Y, Z, 20, cmap='RdGy')
plt.colorbar();

plt.imshow(Z, extent=[0, 5, 0, 5], origin='lower',
           cmap='RdGy')
plt.colorbar()
plt.axis(aspect='image');

#overplot contours with labels
contours = plt.contour(X, Y, Z, 3, colors='black')
plt.clabel(contours, inline=True, fontsize=8)

plt.imshow(Z, extent=[0, 5, 0, 5], origin='lower',
           cmap='RdGy', alpha=0.5)
plt.colorbar();

#A simple histogram with and without binning
%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt
plt.style.use('seaborn-white')
df.info()

plt.hist(df.alm);

plt.hist(df.alm, bins=30, normed=True, alpha=0.5,
         histtype='stepfilled', color='blue',
         edgecolor='none');

# histogram of different columns on one graph from a single dataset
kwargs = dict(histtype='stepfilled', alpha=0.3, normed=True, bins=100)
plt.figure(figsize=(18,6))
plt.hist(df.mcg, **kwargs)
plt.hist(df.gvh, **kwargs)
plt.hist(df.alm, **kwargs);

#plot a two-dimensional histogram is to use Matplotlib's plt.hist2d function
data = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learning-databases/iris/bezdekIris.data',header=None)
data.columns = ['sl','sw','pl','pw','class']

data.info()

plt.figure(figsize=(18,5))
plt.hist2d(data.sl, data.pl, bins=30, cmap='Blues')
cb = plt.colorbar()
cb.set_label('counts in bin')

#plt.hist has a counterpart in np.histogram, plt.hist2d has a counterpart in np.histogram2d
counts, xedges, yedges = np.histogram2d(data.sl, data.pl, bins=30)

plt.figure(figsize=(18,5))
plt.hexbin(data.sl, data.pl, gridsize=30, cmap='Blues')
cb = plt.colorbar(label='count in bin')

import matplotlib.pyplot as plt
plt.style.use('classic')

%matplotlib inline
import numpy as np

fig, ax = plt.subplots()
ax.plot(data.sl, data.pl, '.b', label='Sl')
ax.plot(data.sw, data.pw, '.r', label='Sw')
ax.axis('equal')
leg = ax.legend();

ax.legend(loc='upper left', frameon=False)
fig

ax.legend(frameon=False, loc='lower center', ncol=2)
fig

ax.legend(fancybox=True, framealpha=1, shadow=True, borderpad=1)
fig

# 3D plotting using matplotlib
from mpl_toolkits import mplot3d

%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt

data.info()

def f(x, y):
    return np.sin(np.sqrt(x ** 2 + y ** 2))

x = np.linspace(-6, 6, 30)
y = np.linspace(-6, 6, 30)

X, Y = np.meshgrid(x, y)
Z = f(X, Y)

fig = plt.figure()
ax = plt.axes(projection='3d')
ax.contour3D(X, Y, Z, 50, cmap='binary')
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('z');

fig = plt.figure()
ax = plt.axes(projection='3d')
ax.plot_wireframe(X, Y, Z, color='black')
ax.set_title('wireframe');

ax = plt.axes(projection='3d')
ax.plot_surface(X, Y, Z, rstride=1, cstride=1,
                cmap='viridis', edgecolor='none')
ax.set_title('surface');

theta = 2 * np.pi * np.random.random(1000)
r = 6 * np.random.random(1000)
x = np.ravel(r * np.sin(theta))
y = np.ravel(r * np.cos(theta))
z = f(x, y)
ax = plt.axes(projection='3d')
ax.scatter(x, y, z, c=z, cmap='viridis', linewidth=0.5);

#Visualization-With-Seaborn, Seaborn provides an API on top of Matplotlib

iris = sns.load_dataset("iris")
iris.head()

import seaborn as sns
sns.set()

# same plotting code as above!
plt.plot(iris.sepal_length, iris.sepal_width,'o')
plt.legend('SlSw', ncol=2, loc='upper left');

plt.hist(iris['sepal_length'], normed=True, alpha=0.5)

sns.kdeplot(iris['sepal_length'], shade=True)

data = df
data = pd.DataFrame(data, columns=['mcg', 'gvh', 'alm', 'mit', 'erl', 'pox', 'vac', 'nuc'])
cols = data.columns
for col in cols:
    plt.hist(data[col], normed=True, alpha=0.5)

data = df
data = pd.DataFrame(data, columns=['mcg', 'gvh', 'alm', 'mit', 'erl', 'pox', 'vac', 'nuc'])
cols = data.columns
for col in cols:
    sns.kdeplot(data[col], shade=True)

sns.distplot(data.mcg)

sns.distplot(data.alm)

sns.kdeplot(data)

with sns.axes_style('white'):
    sns.jointplot(data.mcg, data.alm, data, kind='kde');

with sns.axes_style('white'):
    sns.jointplot(data.mcg, data.alm, data, kind='hex');

df.info()
sns.pairplot(df, hue='class', size=2.5);